package com.yc.framework.baseClass;

import java.io.InputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


/**
 * FileName: BaseServiceImpl Description:
 */
public abstract class BaseServiceImpl<Mapper extends BaseMapper<M>, M extends BaseEntity<?>>
        extends ServiceImpl<Mapper, M> implements BaseService<M> {
    public static final String PARAM_IS_ERROR = "传参失败";
    public static final String PARAM_IS_NULL = "参数为空";
    public static final String DATA_IS_NULL = "返回数据为空";
    public static final String SQL_EXCEPTION = "SQL语句错误";

    @Autowired
    @Lazy
    protected ServiceFacade serviceFacade;


    /**
     * 保存实体
     *
     * @param model 实体
     * @return 是否保存成功
     */
    @Transactional
    public R saveModel(M model) {
        if (model == null) {
            return R.err().put("message", PARAM_IS_NULL);
        } else {
            this.initModel(model);
            boolean flag = this.save(model);
//			int t = 0;
//			t = 1 / t;
            return flag ? R.ok().put("data", model) : R.err().put("message", SQL_EXCEPTION);
        }
    }

    /**
     * 保存或修改实体
     *
     * @param model 实体对象
     * @return 是否保存或修改成功
     */
    public R saveOrUpdateModel(M model) {
        if (model == null) {
            return R.err().put("message", DATA_IS_NULL);
        } else {
            this.initModel(model);
            boolean flag = this.saveOrUpdate(model);
            return flag ? R.ok().put("data", model) : R.err().put("message", SQL_EXCEPTION);
        }
    }

    /**
     * 批量保存
     *
     * @param modelList 实体列表
     * @return 是否保存成功
     */
    public R saveModelBatch(Collection<M> modelList) {
        if (modelList != null && modelList.size() != 0) {
            modelList.forEach(this::initModel);
            boolean flag = this.saveBatch(modelList, 100);
            return flag ? R.ok() : R.err().put("message", SQL_EXCEPTION);
        } else {
            return R.err().put("message", DATA_IS_NULL);
        }
    }

    /**
     * 批量保存或修改，没有id则保存，有id则修改
     *
     * @param modelList 实体列表
     * @return 是否成功
     */
    public R saveOrUpdateModelBatch(Collection<M> modelList) {
        if (modelList != null && modelList.size() != 0) {
            modelList.forEach(this::initModel);
            boolean flag = this.saveOrUpdateBatch(modelList, 100);
            return flag ? R.ok() : R.err().put("message", SQL_EXCEPTION);
        } else {
            return R.err().put("message", DATA_IS_NULL);
        }
    }

    /**
     * 根据主键删除
     *
     * @param id 主键
     * @return 是否删除成功
     */
    public R removeModelById(String id) {
        if (super.removeById(id)) {
            return R.ok().put("deleteCount", 1);
        }
        return R.err();
    }

    /**
     * 根据多个主键批删除
     *
     * @param ids 多主键
     * @return 是否删除成功
     */
    public R removeModelByIds(String ids) {
        String[] idst = ids.split(",");
        boolean flg = super.removeByIds(Arrays.asList(idst));
        if (flg) {
            return R.ok().put("deleteCount", idst.length);
        }
        return R.err();
    }


    /**
     * 根据主键修改对象
     *
     * @param model 待修改对象
     * @return 是否修改成功
     */
    public R updateModelById(M model) {
        return updateById(model) ? R.ok().put("data", model) : R.err().put("message", SQL_EXCEPTION);
    }

    /**
     * 根据主键批量一个一个修改
     *
     * @param idList 待修改列表
     * @return 是否修改成功
     */
    @Override
    public R updateModelByIdBatch(List<M> idList) {
        if (idList == null || idList.size() == 0) {
            return R.err().put("message", PARAM_IS_NULL);
        }
        boolean flag = super.updateBatchById(idList);
        return flag ? R.ok() : R.err().put("message", SQL_EXCEPTION);
    }

    /**
     * 根据调解批量修改对象
     *
     * @param model   修改的值
     * @param wrapper 条件
     * @return 是否修改成功
     */
    public R updateModelBatch(M model, Wrapper<M> wrapper) {
        if (model == null) {
            return R.err().put("message", PARAM_IS_NULL);
        } else {
            boolean flag = this.update(model, wrapper);
            return flag ? R.ok().put("data", model) : R.err().put("message", SQL_EXCEPTION);
        }
    }

    /**
     * 根据主键获取对象，并封装至R中
     *
     * @param id 主键
     * @return R结果
     */
    public R getModelById(String id) {
        if (StringUtils.isEmpty(id)) {
            return R.err().put("message", PARAM_IS_NULL);
        } else {
            M m = this.getById(id);
            return m == null ? R.err().put("message", DATA_IS_NULL) : R.ok().put("data", m);
        }
    }

    /**
     * 以List形式 返回所有未被删除的数据，
     *
     * @return List集合
     */
    public List<M> list() {
        QueryWrapper<M> wrapper = new QueryWrapper<>();
//		this.initCondition(wrapper);
        return super.list(wrapper);
    }

    /**
     * 以List形式 返回根据跳槽查询的且未被删除的数据
     *
     * @param model 参数
     * @return List集合
     */
    public List<M> listByModel(M model) {
        QueryWrapper<M> wrapper = new QueryWrapper<>();
        if (model != null) {
            setParam(wrapper, model);
        }
//		this.initCondition(wrapper);
        return super.list(wrapper);
    }



    /**
     * 初始化实体类：设置id、创建时间
     *
     * @param model 实体类对象
     * @param <T>   实体类对象类型
     */
    protected <T extends BaseEntity> void initModel(T model) {
        Date now = new Date();
        //model.setId(model.getId() != null ? model.getId() : DigestUtils.md5Hex(UUID.randomUUID().toString()));
        model.setCreateTime(model.getCreateTime() != null ? model.getCreateTime() : now);
        model.setDeleted(model.getDeleted() != null ? model.getDeleted() : false);
    }

    /**
     * 初始化查询条件：设置查询未删除的
     *
     * @param wrapper 查询条件
     */
    protected void initCondition(@SuppressWarnings("rawtypes") QueryWrapper<? extends BaseEntity> wrapper) {
        // wrapper.eq("deleted", false);
    }

    /**
     * 初始化修改条件：设置查询未删除的
     *
     * @param wrapper 修改条件
     */
    @SuppressWarnings("rawtypes")
    protected void initCondition(UpdateWrapper<? extends BaseEntity> wrapper) {
        // wrapper.eq("deleted", false);
    }

    /**
     * 查询参数设置
     *
     * @param wrapper 查询条件
     * @param model   参数
     */
    protected abstract void setParam(QueryWrapper<M> wrapper, M model);
}
